home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / C / Snippets / Finder Marquee / test_app.c < prev   
Encoding:
C/C++ Source or Header  |  1995-07-10  |  4.5 KB  |  190 lines  |  [TEXT/CWIE]
  1. /*
  2.  
  3.     Finder Marquee
  4.     by Jordan Zimmerman
  5.     (c)1995 by Altura Software, Inc.
  6.  
  7.     Unlimited use is hereby granted without restriction.  However,
  8.     the author would appreciate credit if possible.  Please send
  9.     comments, questions, bugs, etc. to jordanz@altura.com
  10.     
  11.     This code implements a "rubber band" marquee select rect
  12.     with very smooth drawing in a manner similar to the Mac Finder.
  13.  
  14. */
  15.  
  16. #include "finder_marquee.h"
  17.  
  18. static void do_marquee(Point local_pt);
  19. static void draw_highlights(void);
  20. static int selections_proc(finder_marquee_rec* marquee_ptr);
  21. static void change_selection_proc(finder_marquee_rec* marquee_ptr, const Rect* old_marquee_r_ptr);
  22.  
  23. // some simple objects to demonstrate highlighting
  24. typedef struct
  25. {
  26.  
  27.     Rect        bounds_r;
  28.     int            selected_flag;
  29.  
  30. } highlight_rec;
  31.  
  32. highlight_rec    highlights_tab[] =
  33. {
  34.  
  35.     { {10, 10, 42, 42}, false },
  36.     { {50, 75, 82, 107}, false },
  37.     { {100, 10, 132, 42}, false },
  38.     { {110, 200, 142, 232}, false }
  39.  
  40. };
  41.  
  42. // very generic Mac event loop
  43. void main(void)
  44. {
  45.  
  46.     Rect        bounds_r;
  47.     WindowPtr    window_ptr;
  48.     int            is_done = false;
  49.  
  50.     MaxApplZone();
  51.     InitGraf(&qd.thePort);
  52.     InitFonts();
  53.     FlushEvents(everyEvent, 0);
  54.     InitWindows();
  55.     InitMenus();
  56.     TEInit();
  57.     InitDialogs(NULL);
  58.     InitCursor();
  59.     
  60.     InsertMenu(NewMenu(1, "\pFinder Marquee by Jordan Zimmerman"), 0);
  61.     DrawMenuBar();
  62.     
  63.     SetRect(&bounds_r, 50, 50, 300, 250);
  64.     SetPort(window_ptr = NewCWindow(NULL, &bounds_r, "\pPress Any Key To Quit", true, noGrowDocProc, (WindowPtr)-1, false, 0));
  65.     
  66.     while ( !is_done )
  67.     {
  68.         EventRecord        the_event;
  69.         WaitNextEvent(everyEvent, &the_event, GetDblTime(), NULL);
  70.         switch ( the_event.what )
  71.         {
  72.             case keyDown:
  73.             case autoKey:
  74.                 is_done = true;
  75.                 break;
  76.  
  77.             case updateEvt:
  78.                 BeginUpdate(window_ptr);
  79.                 draw_highlights();
  80.                 EndUpdate(window_ptr);
  81.                 break;
  82.                 
  83.             case mouseDown:
  84.                 GlobalToLocal(&the_event.where);
  85.                 do_marquee(the_event.where);
  86.                 break;
  87.         }
  88.     }
  89.     
  90. } // main
  91.  
  92. // here's the meat of the program
  93. // while this example does it all in one function,
  94. // you could just as easily separate the various calls and do it in the background
  95. static void do_marquee(Point local_pt)
  96. {
  97.  
  98.     finder_marquee_rec        marquee;
  99.     
  100.     // the following are necessary only if you want to do your selection
  101.     // while the marquee is being dragged ala the Finder.
  102.     // Set these to NULL if you don't want that functionality
  103.     marquee.selections_proc = selections_proc;
  104.     marquee.change_selection_proc = change_selection_proc;
  105.     
  106.     // start our marquee session
  107.     FinderMarqueeBegin(&marquee, local_pt);
  108.     
  109.     while ( StillDown() )
  110.     {
  111.         Point        new_pt;
  112.         long        dummy;
  113.         
  114.         GetMouse(&new_pt);
  115.         
  116.         // do the next point
  117.         FinderMarqueeContinue(&marquee, new_pt);
  118.         
  119.         // a little delay makes things look smoother
  120.         Delay(1, &dummy);
  121.     }
  122.     
  123.     // finish our marquee session
  124.     FinderMarqueeEnd(&marquee);
  125.  
  126. } // do_marquee
  127.  
  128. // walk through our highlight rects and see if any of the selections will change.
  129. // the marquee drawing must work slightly differently if there's going to be
  130. // a selection change.
  131. // If there's no selection change, the marquee can be drawn in one step (PaintRgn)
  132. // that will erase the old and draw the new.  If there is a selection, though, the
  133. // old marquee must be erased, the selections must be drawn, and then the new marquee
  134. // can be drawn.
  135. static int selections_proc(finder_marquee_rec* marquee_ptr)
  136. {
  137.  
  138.     int                i;
  139.     int                qty = sizeof(highlights_tab) / sizeof(*highlights_tab);
  140.     highlight_rec*    tab_ptr = highlights_tab;
  141.     for ( i = 0; i < qty; ++i, ++tab_ptr )
  142.     {
  143.         Rect        sect_r;
  144.         if ( SectRect(&marquee_ptr->marquee_r, &tab_ptr->bounds_r, §_r) != tab_ptr->selected_flag )
  145.         {
  146.             return true;
  147.         }
  148.     }
  149.     
  150.     return false;
  151.  
  152. } // selections_proc
  153.  
  154. // invert any of the highlight rects that intersect the current marquee rect
  155. static void change_selection_proc(finder_marquee_rec* marquee_ptr, const Rect* old_marquee_r_ptr)
  156. {
  157.  
  158.     int                i;
  159.     int                qty = sizeof(highlights_tab) / sizeof(*highlights_tab);
  160.     highlight_rec*    tab_ptr = highlights_tab;
  161.     for ( i = 0; i < qty; ++i, ++tab_ptr )
  162.     {
  163.         Rect        sect_r;
  164.         if ( SectRect(&marquee_ptr->marquee_r, &tab_ptr->bounds_r, §_r) != tab_ptr->selected_flag )
  165.         {
  166.             tab_ptr->selected_flag = !tab_ptr->selected_flag;
  167.             InvertRect(&tab_ptr->bounds_r);
  168.         }
  169.     }
  170.  
  171. } // change_selection_proc
  172.  
  173. // draw in response to an update event
  174. static void draw_highlights(void)
  175. {
  176.  
  177.     int                i;
  178.     int                qty = sizeof(highlights_tab) / sizeof(*highlights_tab);
  179.     highlight_rec*    tab_ptr = highlights_tab;
  180.     for ( i = 0; i < qty; ++i, ++tab_ptr )
  181.     {
  182.         FrameRect(&tab_ptr->bounds_r);
  183.         if ( tab_ptr->selected_flag )
  184.         {
  185.             InvertRect(&tab_ptr->bounds_r);
  186.         }
  187.     }
  188.  
  189. } // draw_highlights
  190.